# 作业：
# 一、定义一个学生Student类。有下面的实例属性：
# 1 姓名 name
# 2 年龄 age
# 3 成绩 score（语文，数学，英语) [每课成绩的类型为整数]
# 类方法：
#  1 获取学生的姓名：get_name() 返回类型:str
# 2 获取学生的年龄：get_age() 返回类型:int
# 3 返回3门科目中最高的分数。get_course() 返回类型:int
# 4 将每个实例学生对象写进txt文件里，要持久保存
# 举例：{"姓名":"a","年龄":29,"成绩":{"语文":99,"数学":100,"英语":85}
# 5 获取所有学生的信息
# 写好类以后，可以定义2个同学测试下:
# zm = Student('zhangming',20,[69,88,100])
"""
class Student: # Student 类
    def __init__(self,name,age,score): #类方法 name，age，score
        self.name = name
        self.age = age
        self.score = score
        f = open('student_day.txt','r',encoding='utf-8') #去重复
        if self.name in f.read(): # 如果self.name 在 f.read里
            pass #过
        else: #否则
            with open('student_day.txt','a',encoding='utf-8') as f: #追加写入
                f.write(str({"姓名":self.name,"年龄":self.age,"成绩":{"语文":score[0],"数学":score[1],"英语":score[2]}}) + "\n")
    def get_name(self): #类方法
        return f"学生姓名为：{self.name}"
    def get_age(self):
        return f"学生的年龄是：{self.age}"
    def get_course(self):
        max_couse= self.score[0]
        if max_couse < self.score[1]:
            max_couse = self.score[1]
        if max_couse < self.score[2]:
            max_couse = self.score[2]
        return max_couse        #这个函数通过比较列表中的分数找到最大值，然后将其返回。

zm = Student('zhangming',20,[69,101,100])
print(zm.get_course())
"""
# 二、定义一个字典类：dictclass。完成下面的功能：
# 1 删除某个key
# 2 判断某个键是否在字典里，如果在返回键对应的值，不存在则返回"not found"
# 3 返回键组成的列表：返回类型;(list)
# 4 合并字典，并且返回合并后字典的values组成的列表。返回类型:(list)
"""
class Dictclass:   #类Dictclass
    def __init__(self,dict1:dict):# 类属性
        self.dict1 = dict1 
    def random_del(self): #类方法 
        import random #导入random模块
        self.dict1.pop(random.choice([i for i in self.dict1.keys()]))# 随机删除某个key
    def del_dict(self,key):# 类方法
        try:  
            del self.dict1[key] #删除self.dict1 的key
        except:
            print(f"您输入的{key}不存在的字典里") #如果try语句中有错误的走except
            print(f"not found")
    def get_list(self):# 类方法
        return [i for i in self.dict1.keys()]# 返回键组成的列表
    def dict_update(self,dict2):#类方法
        self.dict1.update(dict2)#更新字典并合并字典
        return [i for i in self.dict1.values()]#返回值组成的列表 
"""
# 四、定义一个列表的操作类：Listinfo
# 包括的方法:
# 1 列表元素添加: add_key(keyname) [keyname:字符串或者整数类型]
# 2 列表元素取值：get_key(num) [num:整数类型]
# 3 列表合并：update_list(list) [list:列表类型]
# 4 删除并且返回最后一个元素：del_key()
"""
class Listinfo:
    def __init__(self,my_list):
        self.my_list = my_list
    def add_key(self,keyname):
        self.my_list.append(keyname)
        print(f"添加了元素{keyname}到列表")
    def get_key(self,num):
        if 0<= num <len(self.my_list):
            return int(self.my_list[num])
    def update_list(self,list1):
        self.my_list.extend(list1)
        print("列表合并了傻逼")
    def del_key(self):
        if len(self.my_list) >0:
            return self.my_list.pop()
a= Listinfo([1, 2, 3, 4, 5])
a.add_key(6)
print(f"取值：{a.get_key(2)}")
a.update_list([7, 8, 9])
print(f"删除并返回最后一个元素：{a.del_key()}")
print("最终列表：", a.my_list)
"""
#  五、做一个学生点名系统，系统里支持：存入学生、更改学生、删除学生、点到学生姓名方法
# 存入学生（姓名、年龄、家庭地址、手机号）： 存入成功后，提示xxx存入成功
# 更改学生（姓名、年龄、家庭地址、手机号）：可以修改学生内容的任意一个字段
# 删除学生：删除的学生将不在展示
# 展示全部学生：可以看到全部的学生姓名
# 学生姓名：随机抽取任意一个存在的学生信息，然后打印：到！。举例： 刘闯到！
"""
import random
class Student:
    def __init__(self):
        self.students ={}
    def add_student(self, name,age,address,phone_number):
        student_info = {"姓名":name,"年龄":age,"地址":address,"电话":phone_number}
        self.students[name] = student_info
    def update_student(self, name, age=None, address=None, phone_number=None):
        if name in self.students:
            student_info = self.students[name]
            if age is not None:
                student_info['年龄'] = age
            if address is not None:
                student_info['地址'] = address
            if phone_number is not None:
                student_info['手机号'] = phone_number
            print(f"{name}的信息已更新")
        else:
            print(f"{name}不存在")
    def delete_student(self, name):
        if name in self.students:
            del self.students[name]
            print(f"{name}已删除")
        else:
            print(f"{name}不存在")
    def display_all_students(self):
        print("全部学生姓名：")
        for name in self.students:
            print(name)
    def point_to_student(self):
        if len(self.students) == 0:
            print("学生列表为空")
            return
        random_student = random.choice(list(self.students.keys()))
        print(f"{random_student}到！")
sms = Student()
# 添加学生
sms.add_student("张三", 20, "北京", "1234567890")
sms.add_student("李四", 22, "上海", "9876543210")
# 修改学生信息
sms.update_student("张三", age=21, phone_number="1111111111")
# 展示全部学生
sms.display_all_students()
# 点到学生姓名
sms.point_to_student()
"""
# 六、点餐管理系统
# 1》、餐馆可以新增菜品、下架菜品、修改菜品
# 2》、每个菜品，都有对应的库存，所有菜品的库存均为999，每出一道菜，库存-1
# 菜品有对应的价格，餐厅老板定义价格每道菜不允许超过15元，没有小数单位，均为整数
# 3》、餐馆后台有点赞系统，能够收集客户对菜品的喜好，0~5分
# 4》、有菜品评分提报功能，对平均分数（菜品总分/打分人数）低于3分的菜品进行强制下架；
""" ### #不会不会不会！！！！！！！！！！！！！！！！！！！
class Restaurant:
    def __init__(self):
        self.menu = {}  # 菜单，字典形式存储菜品信息
        self.likes = {}  # 点赞系统，字典形式存储菜品的喜好和评分信息

    def add_dish(self, dish_name, price):
        if dish_name not in self.menu:
            if price <= 15:
                self.menu[dish_name] = {"price": price, "stock": 999}
                self.likes[dish_name] = {"total_score": 0, "num_of_scores": 0}
                print(f"新增菜品：{dish_name}，价格：{price}元，库存：999。")
            else:
                print("菜品价格不能超过15元。")
        else:
            print(f"菜品已存在：{dish_name}。")

    def remove_dish(self, dish_name):
        if dish_name in self.menu:
            del self.menu[dish_name]
            del self.likes[dish_name]
            print(f"下架菜品：{dish_name}。")
        else:
            print(f"菜品不存在：{dish_name}，无法下架。")

    def modify_dish(self, dish_name, new_price):
        if dish_name in self.menu:
            if new_price <= 15:
                self.menu[dish_name]["price"] = new_price
                print(f"修改菜品：{dish_name}，新价格：{new_price}元。")
            else:
                print("菜品价格不能超过15元。")
        else:
            print(f"菜品不存在：{dish_name}，无法修改。")

    def order_dish(self, dish_name):
        if dish_name in self.menu and self.menu[dish_name]["stock"] > 0:
            print(f"下单成功，{dish_name}价格：{self.menu[dish_name]['price']}元。")
            self.menu[dish_name]["stock"] -= 1
        else:
            print("抱歉，菜品不存在或库存不足。")

    def like_dish(self, dish_name, score):
        if dish_name in self.likes and 0 <= score <= 5:
            self.likes[dish_name]["total_score"] += score
            self.likes[dish_name]["num_of_scores"] += 1
            print(f"感谢您对{dish_name}的喜好评分！")
        else:
            print("无法进行评分，菜品不存在或评分不合法。")

    def check_average_score(self):
        for dish_name, info in self.likes.items():
            if info["num_of_scores"] > 0:
                average_score = info["total_score"] / info["num_of_scores"]
                if average_score < 3:
                    self.remove_dish(dish_name)
                    print(f"菜品：{dish_name}，平均分低于3分，已强制下架。")


# 示例使用：
restaurant = Restaurant()

# 新增菜品
restaurant.add_dish("麻辣香锅", price=12)
restaurant.add_dish("宫保鸡丁", price=14)
restaurant.add_dish("清蒸鲈鱼", price=18)  # 超过15元，无法添加
restaurant.add_dish("麻辣香锅", price=10)  # 已存在，无法添加

# 点赞和下单
restaurant.like_dish("麻辣香锅", score=4)
restaurant.like_dish("宫保鸡丁", score=5)
restaurant.order_dish("麻辣香锅")
restaurant.order_dish("宫保鸡丁")
restaurant.order_dish("清蒸鲈鱼")  # 不存在，无法下单

# 修改和下架菜品
restaurant.modify_dish("宫保鸡丁", new_price=16)
restaurant.check_average_score()

# 输出菜单信息
print("当前菜单信息：", restaurant.menu)

"""
#  七、定义一个桌子类（Desk），包含长（length）、宽（width）、高（height）属性，
# 包含一个打印桌子信息属性的方法（showInfo）。实例化2个桌子对象，为其赋予不同的属性值，
# 并调用showInfo方法，输出每个桌子的信息。
"""
class Desk:
    def __init__(self, length, width, height):
        self.length = length
        self.width = width
        self.height = height
    def showInfo(self):
        print(f"桌子信息：长 {self.length}，宽 {self.width}，高 {self.height}")
desk1 = Desk(length=120, width=80, height=75)#实例化两个桌子对象，分别赋予不同的属性值
desk2 = Desk(length=150, width=90, height=70)
desk1.showInfo()
desk2.showInfo()
"""
# 八、定义一个用户类(User),用户名(username)和密码(password)是这个类的属性。
"""
class User:
    def __init__(self,username,password):
        self.username = username
        self.password = password
user1 = User(username="admin",password="123456")#对象
print("用户名",user1.username)
print("密码",user1.password)
"""
# 九、定义一个计算器类，有加减乘除四个方法
"""
class Com:
    def __init__(self,a,b):
        self.a = a
        self.b = b
    def jia(self):
        return self.a+self.b
    def jian(self):
        return self.a - self.b
    def cheng(self):
        return self.a * self.b
    def chu(self):
        return self.a / self.b
aa = Com(45,3)
print(f"傻逼这是加{aa.jia()},傻逼这是减{aa.jian()},傻逼这是乘{aa.cheng()},傻逼这是除{aa.chu()}")
"""
# 十、创建一个名为Person的类，具有以下属性和方法：
# 属性：name（姓名），age（年龄）
# 方法：greet()，打印出一句问候语，包括该人的姓名和年龄
"""
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def greet(self):
        print(f"傻逼东西,姓名是 {self.name} , 我是 {self.age}")
a =Person(name="大傻逼",age="老王八")
a.greet()
"""
# 十一、定义一个图书管理系统类，图书可以新增、修改、删除，要求新增的每个图书都加到txt文本里，数据持久化
# 新增：图书名、作者名称、新建年月日
# 修改：图书名、作者名称、新建年月日
# 删除：图书删掉，且不在展示
# 查看：全量查询，精确查询，需要用户传入形参来控制返回结果
""" 
import os ###不会！！！！！！！！
from datetime import datetime

class Book:
    def __init__(self, title, author, created_date):
        self.title = title
        self.author = author
        self.created_date = created_date

class LibrarySystem:
    def __init__(self):
        self.books = []  # 存储图书对象的列表
        self.data_file = "library_data.txt"  # 持久化数据的文件

    def load_data(self):
        if os.path.exists(self.data_file):
            with open(self.data_file, 'r') as file:
                lines = file.readlines()
                for line in lines:
                    book_info = line.strip().split(',')
                    title, author, created_date = book_info
                    book = Book(title, author, created_date)
                    self.books.append(book)

    def save_data(self):
        with open(self.data_file, 'w') as file:
            for book in self.books:
                file.write(f"{book.title},{book.author},{book.created_date}\n")

    def add_book(self, title, author):
        created_date = datetime.now().strftime("%Y-%m-%d")
        new_book = Book(title, author, created_date)
        self.books.append(new_book)
        self.save_data()
        print(f"新增图书：{title}，作者：{author}，创建日期：{created_date}")

    def modify_book(self, title, author, new_title, new_author):
        for book in self.books:
            if book.title == title and book.author == author:
                book.title = new_title
                book.author = new_author
                self.save_data()
                print(f"修改图书：{title}，作者：{author} -> 新标题：{new_title}，新作者：{new_author}")
                return
        print(f"未找到图书：{title}，作者：{author}")

    def delete_book(self, title, author):
        for book in self.books:
            if book.title == title and book.author == author:
                self.books.remove(book)
                self.save_data()
                print(f"删除图书：{title}，作者：{author}")
                return
        print(f"未找到图书：{title}，作者：{author}")

    def show_books(self, filter_type=None, filter_value=None):
        filtered_books = []
        if filter_type == "title":
            filtered_books = [book for book in self.books if filter_value.lower() in book.title.lower()]
        elif filter_type == "author":
            filtered_books = [book for book in self.books if filter_value.lower() in book.author.lower()]
        elif filter_type is None:
            filtered_books = self.books

        if filtered_books:
            print("图书列表：")
            for book in filtered_books:
                print(f"标题：{book.title}，作者：{book.author}，创建日期：{book.created_date}")
        else:
            print("未找到符合条件的图书。")


# 示例使用：
library_system = LibrarySystem()

# 载入已有数据
library_system.load_data()

# 新增图书
library_system.add_book("The Great Gatsby", "F. Scott Fitzgerald")
library_system.add_book("To Kill a Mockingbird", "Harper Lee")

# 修改图书
library_system.modify_book("The Great Gatsby", "F. Scott Fitzgerald", "Gatsby", "Fitz")

# 删除图书
library_system.delete_book("To Kill a Mockingbird", "Harper Lee")

# 查看图书
library_system.show_books()  # 全量查询
library_system.show_books("title", "Gatsby")  # 标题精确查询
library_system.show_books("author", "Fitz")  # 作者精确查询


"""
# 十二、创建一个名为"Car"的类，该类具有"品牌"和"颜色"属性。
# 创建一个"start_engine"方法，该方法打印出"启动汽车引擎！"的消息。
# 创建一个"stop_engine"方法，该方法打印出"关闭汽车引擎！"的消息
"""
class Car:
    def __init__(self,brand,color):
        self.brand = brand
        self.color = color
    def start_engine(self):
        print(f"{self.brand}启动汽车引擎,颜色是{self.color}")
    def stop_engine(self):
        print(f"{self.brand}关闭汽车引擎")
car1 = Car(brand ="Mercedes",color ="pink")
car1.start_engine()
car1.stop_engine()
"""
# 十三、淘宝商家后台，可以上架商品、下架商品，功能如下：
#  （1） 可以添加商品，商家添加完的商品会存到商品列表
#  1.1  商品要有名称、sku、价格
#  （2） 可以修改商品信息：名称、sku、价格
#  （3） 可以对商品进行下架，下架后的商品不再展示
"""
class Product:
    def __init__(self, name, sku, price, status='Active'):
        self.name = name
        self.sku = sku
        self.price = price
        self.status = status  # 商品状态，默认为Active

    def update_product(self, name, sku, price):
        self.name = name
        self.sku = sku
        self.price = price

    def deactivate_product(self):
        self.status = 'Inactive'


class SellerBackend:
    def __init__(self):
        self.products = []  # 存储商品对象的列表

    def add_product(self, name, sku, price):
        new_product = Product(name, sku, price)
        self.products.append(new_product)
        print(f"商品已添加：{name}, SKU: {sku}, 价格: {price}")

    def find_product(self, sku):
        for product in self.products:
            if product.sku == sku:
                return product
        return None

    def update_product(self, sku, name, new_sku, price):
        product = self.find_product(sku)
        if product:
            product.update_product(name, new_sku, price)
            print(f"商品已更新：{name}, 新SKU: {new_sku}, 新价格: {price}")
        else:
            print("未找到该商品")

    def deactivate_product(self, sku):
        product = self.find_product(sku)
        if product:
            product.deactivate_product()
            print(f"商品已下架：{product.name}")
        else:
            print("未找到该商品")

# 示例使用：
seller_backend = SellerBackend()

# 添加商品
seller_backend.add_product("手机", "SKU123", 999.99)
seller_backend.add_product("笔记本电脑", "SKU456", 1999.99)

# 修改商品信息
seller_backend.update_product("SKU123", "新手机", "NEW_SKU123", 1099.99)

# 下架商品
seller_backend.deactivate_product("SKU456")

"""   #不会！！！！！！！！！！！
# 十四、定义一个人类
# 1.小明和小美都爱跑步
# 2.小美体重45.0公斤
# 3.小明体重75.0公斤
# 4.每次跑步都会减少0.5公斤
# 5.每次吃东西都会增加1公斤
"""
class Humans: #humans 人类
    def __init__(self,name,weight):
        self.name = name
        self.weight =weight
    def run(self):
        print(f"{self.name}喜欢跑步")
        self.weight -= 0.5
        print(f"{self.name}跑步后体重减少0.5公斤，当前体重为{self.weight}公斤")
    def eat(self):
        print(f"{self.name}喜欢吃东西")
        self.weight += 1
        print(f"{self.name}吃东西后体重增加1公斤，当前体重为{self.weight}公斤")
xiaoming = Humans("小明",75.0)
xiaomei = Humans("小美",45.0)
xiaoming.run()
xiaomei.run()
xiaoming.eat()
xiaomei.eat()
print(f"小美的体重是{xiaomei.weight}公斤")
print(f"小明的体重是{xiaoming.weight}公斤")
"""
# 十五、士兵瑞恩有一把ak47
# 士兵可以开火（开火扣动的是扳机）
# 枪能够发射子弹（把子弹打出去）
# 抢能够装子弹–增加子弹数量
# 要求没子弹，需要输出没有子弹了，且发射失败

# 不会！！
"""
class SoldierRyan:   #士兵瑞恩
    def __init__(self): 
        self.bulletlist = 25 #弹药列表  
        self.nowbullet = 0 #当前子弹
    def Ammunition(self): #获取弹药
        if self.bulletlist >= 5: #如果弹药列表>=5
            self.nowbullet +=5  #当前子弹+5
            self.bulletlist -=5弹药列表-5
        else:
            print("弹药不足，添加失败！")
    def openfire(self,bullet): # bullet：子弹  openfire：开火
        if self.nowbullet:
            if self.nowbullet >= bullet:  如果当前子弹>=子弹
                self.nowbullet -=bullet 当前子弹-子弹
                print(f"发射成功！")
            else:
                print(f"发射失败，弹药不足，不够本次发射")
"""




